from rest_framework.views import APIView, View  # api视图接口
from rest_framework import serializers  # 序列化器
from rest_framework.response import Response
from django.http.response import JsonResponse  # drf的回应
from rest_framework.viewsets import ModelViewSet
from bookshop.models import UserInfo, Book
from bookshop.sers import UserModelSerializer, BookModelSerializer
from .filters import UserFilter


# 自动导包快捷键：alt+回车

class UserModelViewSet(ModelViewSet):
    queryset = UserInfo.objects.all()
    serializer_class = UserModelSerializer
    filter_class = UserFilter  # 使用过滤器


class UserInfoView(View):
    """模拟序列化器"""

    def get(self, request):
        """序列化一个模拟对象"""
        # 1.获取数据集
        userinfo = UserInfo.objects.all()
        # 2.实例化序列化器，获得序列对象
        serializer = UserModelSerializer(instance=userinfo, many=True)
        # 3.调用序列化对象的Data属性方法获取转化后的数据
        data = serializer.data
        # 4.相应数据
        return Response(data)

    def post(self, request, *args, **kwargs):
        print(request.data, type(request.data))
        serializer = UserModelSerializer(data=request.data)
        # 把前端拿到的数据付过来了，然后对拿过来的数据进行序列化

        if serializer.is_valid(raise_exception=True):
            # 做校验,并且返回一个布尔值
            # 如果结果为真的话，把这些数据存到数据库中

            # 方法一
            # stu = UserInfo.objects.create(**serializer.validated_data)
            # 存到数据库中以后并对前端返回一个序列化后的结果，
            # ser = UserModelSerializer(instance=stu, many=False)
            # return Response(ser.data)

            # 方法二：
            serializer.save()
            return Response(serializer.data)
        else:
            # 如果结果为假的话，那么就将校验中的错误信息返回给前端的桌面
            return Response(serializer.errors)

    def delete(self, request, id):  # 删除的逻辑
        UserInfo.objects.get(pk=id).delete()
        return Response()

    def put(self, request, id):  # 更新的逻辑
        print(request.data, type(request.data))
        serializer = UserModelSerializer(data=request.data)
        # 把前端拿到的数据付过来了，然后对拿过来的数据进行序列化
        if serializer.is_valid(raise_exception=True):
            # 做校验,并且返回一个布尔值
            # 如果结果为真的话，把这些数据存到数据库中

            # 方法一：
            # stu = UserInfo.objects.filter(pk=id).update(**serializer.validated_data)
            # 这里的stu是个数字不能进行传对象，我们要把序列化的对象传进去
            # 存到数据库中以后并对前端返回一个序列化后的结果，
            # stu1 = UserInfo.objects.get(id=id)
            # ser = UserModelSerializer(instance=stu1, many=False)
            # return Response(ser.data)

            # 方法二：
            serializer.save()
            return Response(serializer.data)
        else:
            # 如果结果为假的话，那么就将校验中的错误信息返回给前端的桌面
            return Response(serializer.errors)




class UserInfoView(View):
    """模拟序列化器"""

    def get(self, request):
        """序列化一个模拟对象"""
        # 1.获取数据集
        books = Book.objects.all()
        # 2.实例化序列化器，获得序列对象
        serializer = BookModelSerializer(instance=Book, many=True)
        # 3.调用序列化对象的Data属性方法获取转化后的数据
        data = serializer.data
        # 4.相应数据
        return Response(data)

    def post(self, request, *args, **kwargs):
        print(request.data, type(request.data))
        serializer = BookModelSerializer(data=request.data)
        # 把前端拿到的数据付过来了，然后对拿过来的数据进行序列化
        if serializer.is_valid(raise_exception=True):
            # 做校验,并且返回一个布尔值
            # 如果结果为真的话，把这些数据存到数据库中

            # 方法一：
            # stu = Books.objects.create(**serializer.validated_data)
            # 存到数据库中以后并对前端返回一个序列化后的结果，
            # ser = BooksModelSerializer(instance=stu, many=False)
            # return Response(ser.data)
            serializer.save(pk=id)
            return Response(serializer.data)
        else:
            # 如果结果为假的话，那么就将校验中的错误信息返回给前端的桌面
            return Response(serializer.errors)

    def delete(self, request, id):  # 删除的逻辑
        Book.objects.get(pk=id).delete()
        return Response("已删除")

    def put(self, request, id):  # 更新的逻辑
        print(request.data, type(request.data))
        serializer = BookModelSerializer(data=request.data)
        # 把前端拿到的数据付过来了，然后对拿过来的数据进行序列化
        if serializer.is_valid(raise_exception=True):
            # 做校验,并且返回一个布尔值
            # 如果结果为真的话，把这些数据存到数据库中

            # 方法一：
            # stu = Books.objects.filter(pk=id).update(**serializer.validated_data)
            # 这里的stu是个数字不能进行传对象，我们要把序列化的对象传进去
            # 存到数据库中以后并对前端返回一个序列化后的结果，
            # stu1 = Books.objects.get(id=id)
            # ser = BooksModelSerializer(instance=stu1, many=False)
            # return Response(ser.data)

            # 方法二
            serializer.save(pk=id)
            return Response(serializer.data)
        else:
            # 如果结果为假的话，那么就将校验中的错误信息返回给前端的桌面
            return Response(serializer.errors)

# 序列化器的使用:
# from rest_framework.views import APIView  # api视图接口
# from rest_framework import serializers  # 序列化器
# from rest_framework.response import Response  # drf的回应
#
# from bookshop.models import UserInfo
#
#
# class UserInfoSerializer(serializers.Serializer):
#     # 在该类下面写的数量就可以控制最后出现在数据表上的结果
#     phone = serializers.CharField(max_length=100)
#     # 键值表示，展示的时候展示左边的这个，调用的时候调用右边这个
#     code = serializers.CharField(max_length=100)
#     name = serializers.CharField(max_length=16)
#     age = serializers.IntegerField()
#     idcard = serializers.CharField(max_length=64)
#
#
# class LoginView(APIView):
#     # drf的api接口， 标准是get，post，delete，put
#     def get(self, request):
#         users = UserInfo.objects.all()  # 查询所有数据
#         serializer = UserInfoSerializer(instance=users, many=True)
#         # 序列化器通过对数据的处理得到自己想要的类型，instance是序列化，data是反序列化
#         # many=true是一对多，也就是用for循环遍历，如果是一对一，则就是false
#         return Response(serializer.data)
#         # 通过Response 再一次修改格式，使得格式更加符合我们的使用和输出
#
#     def post(self, request, *args, **kwargs):
#         print(request.data, type(request.data))
#         serializer = UserInfoSerializer(data=request.data)
#         # 把前端拿到的数据付过来了，然后对拿过来的数据进行序列化
#         if serializer.is_valid(raise_exception=True):
#             # 做校验,并且返回一个布尔值
#             # 如果结果为真的话，把这些数据存到数据库中
#             stu = UserInfo.objects.create(**serializer.validated_data)
#             # 存到数据库中以后并对前端返回一个序列化后的结果，
#             ser = UserInfoSerializer(instance=stu, many=False)
#             return Response(ser.data)
#         else:
#             # 如果结果为假的话，那么就将校验中的错误信息返回给前端的桌面
#             return Response(serializer.errors)
#
#
# class UserDetailView(APIView):
#
#     def get(self, request, id):  # 查看某一个
#         users = UserInfo.objects.get(pk=id)  # 取出某一个的id
#         serializer = UserInfoSerializer(instance=users, many=False)
#         # 序列化取出单一的数据进行序列化操作，并赋给serializer
#         return Response(serializer.data)
#         # 最后用drf的相应进行操作
#
#     def delete(self, request, id):  # 删除的逻辑
#         UserInfo.objects.get(pk=id).delete()
#         return Response()
#
#     def put(self, request, id):  # 更新的逻辑
#         print(request.data, type(request.data))
#         serializer = UserInfoSerializer(data=request.data)
#         # 把前端拿到的数据付过来了，然后对拿过来的数据进行序列化
#         if serializer.is_valid(raise_exception=True):
#             # 做校验,并且返回一个布尔值
#             # 如果结果为真的话，把这些数据存到数据库中
#             stu = UserInfo.objects.filter(pk=id).update(**serializer.validated_data)
#             # 这里的stu是个数字不能进行传对象，我们要把序列化的对象传进去
#             # 存到数据库中以后并对前端返回一个序列化后的结果，
#             stu1 = UserInfo.objects.get(id=id)
#             ser = UserInfoSerializer(instance=stu1, many=False)
#             return Response(ser.data)
#         else:
#             # 如果结果为假的话，那么就将校验中的错误信息返回给前端的桌面
#             return Response(serializer.errors)


